Kapitel 20 Tastatur- und Mausereignisse

20.1 Die Tastaturschnittstelle 

Die Tastatur ist die wichtigste Eingabeschnittstelle, deren Tasten entweder mit Zeichencodes oder allgemeinen Funktionen verknüpft sind. Ganz allgemein betrachtet lassen sich die Tasten der Tastatur in vier Gruppen einteilen:

Zeichentasten: Zu diesen zählen alle Tasten, mit denen Buchstaben, Zahlen und Symbole eingegeben werden können. Bei den verarbeiteten Zeichencodes handelt es sich um die Zeichen des ASCII-Zeichensatzes, die intern als 16-Bit-Unicode behandelt werden.

Zustandstasten: Zu dieser Gruppe gehören drei Tasten: die (Alt)-, die (Strg)- und die (Shift)-Taste. In Kombination mit einer Zeichen- oder Funktionstaste können diese Tasten von einer eingabefähigen Komponente in einer vorgeschriebenen Weise interpretiert werden.

Funktionstasten: Tasten, die dieser Gruppe zugeordnet werden, führen eine bestimmte Funktionalität aus. Dazu gehören die (Einf)-, (Pause)- und die (Entf)-Taste ebenso wie die Funktionstasten (F1) bis (F12) und die Cursortasten.

Ein-/Aus-Tasten: Diese Tasten bilden die kleinste Gruppe. Zu ihnen gehören die (Num)- und die (Rollen)-Taste.

Tastatureingaben des Anwenders werden von der fokussierten Komponente entgegengenommen. Die elementarsten Reaktionen auf die Eingaben werden von der Komponente selbst ausgeführt. Beispielsweise können Sie in eine Textbox Zeichen eingeben, mit der Rücktaste das vor dem Eingabecursor stehende Zeichen löschen usw. Sollen bei einer Eingabe Reaktionen erfolgen, die über den internen Standard hinausgehen, muss das codiert werden. Damit ließe sich zum Beispiel erreichen, dass das Drücken der (F8)-Taste einen anwendungsspezifischen Dialog öffnet oder bestimmte Zeichen der Benutzereingabe nicht weiterverarbeitet werden.

20.1.1 Die Tastaturereignisse im Überblick 

In der Klasse Control sind drei Ereignisse definiert, welche die Tastatureingabe behandeln: KeyDown, KeyPress und KeyUp. Allerdings veröffentlichen nicht alle von der Basisklasse Control abgeleiteten Komponenten diese drei Ereignisse, denn Voraussetzung dafür ist die Fokussierfähigkeit. Ein Label beispielsweise reiht sich zwar in die Fokussierreihenfolge ein, ist aber nicht in der Lage, Tastatureingaben zu verarbeiten.

Sehen wir uns nun zuerst die Definition der drei Tastaturereignisse an:

KeyDown und KeyUp sind mit dem so genannten Tastaturcode verknüpft, der für jede Taste eindeutig festgelegt. Daher werden diese beiden Ereignisse bei einem Tastaturanschlag grundsätzlich ausgelöst:

KeyDown, wenn die Taste gedrückt wird und

KeyUp, wenn die Taste losgelassen wird.

Das Ereignis KeyPress tritt nach KeyDown nur dann ein, wenn der Anwender auf eine Buchstaben- oder Zifferntaste drückt. Dabei sind aber auch noch einige Sonderfälle zu berücksichtigen:

Wird eine Tastenkombination aus einer oder mehreren Zustandstasten zusammen mit einer Taste für Zeichencode gedrückt, z.  B. (Shift) + (A), wird das KeyDown-Ereignis sowohl für die Zustandstaste als auch für die Zeichentaste ausgelöst. Dasselbe gilt auch für KeyUp.

Hält man eine Zustandstaste längere Zeit gedrückt, tritt KeyDown wiederholt auf.

Wird eine Zeichentaste längere Zeit gedrückt, schreibt sich das Zeichen wiederholt in das Ausgabeziel, beispielsweise in eine Textbox. Dabei tritt für die Dauer des Tastendrucks das Ereignispaar KeyDown/KeyPress so lange auf, bis die Taste losgelassen wird (was ein abschließendes KeyUp bewirkt).

Ist in einer Textbox die Eigenschaft AcceptsTab auf True gesetzt, kann der Benutzer mit der (Tab)-Taste ein Tabstopp-Zeichen in ein mehrzeiliges Textfeld eingeben. In diesem Fall wird kein Tastaturereignis ausgelöst.

KeyPress tritt nur auf, wenn das Ausgabeziel ein ASCII-Zeichen ist. Das gilt auch für den Fall, dass eine Kombination aus zwei Zustandstasten mit einer Zeichentaste gedrückt wird (z.  B. (Strg) + (Alt) + (Q) für das Zeichen @, das ist mit der Tastenkombination (AltGr) + (Q) identisch).

20.1.2 Die Ereignisse »KeyDown« und »KeyUp« 

Eine Methode, die ein ausgelöstes Ereignis behandelt, muss eine Parameterliste aufweisen, die dem Typ des Delegaten des Ereignisses entspricht. Sowohl KeyDown als auch KeyUp sind vom Typ KeyEventHandler, dessen Definition wie folgt lautet:

Das Objekt vom Typ KeyEventArgs, das der Ereignishandler in Empfang nimmt, enthält für uns wichtige Informationen, mit denen die Ursache der Ereignisauslösung exakt beschrieben wird.

Die Eigenschaften Alt, Control und Shift geben einzeln darüber Auskunft, ob die gleichnamige Zustandstaste gedrückt ist, Modifiers kombiniert diese drei Informationen in einem Wert. KeyData und KeyValue haben zwar denselben Informationsgehalt, unterscheiden sich jedoch im Typ der Rückgabe. KeyData enthält die Tastaturcodes aller gleichzeitig gedrückten Tasten und ist somit die Zusammenfassung der Eigenschaften KeyCode und Modifiers.

Die Eigenschaft »KeyCode« und die Enumeration »Keys«

Drei Eigenschaften in der Tabelle 20.1 sind von einem Typ, den wir bisher noch nicht kennen: Keys.

Jede Taste einer Tastatur wird durch eine eindeutige Zahl beschrieben, dem Tastaturcode. Die Enumeration Keys beschreibt alle denkbaren Tastencodes. Alle Konstanten hier wiederzugeben, würde einige Seiten des Buchs füllen und Sie sicherlich langweilen. Deshalb möchte ich nur die wichtigsten vorstellen, auf die Sie bei der täglichen Programmierung häufig zugreifen. Der besseren Übersicht wegen habe ich sie in mehrere logische Gruppen zusammengefasst.

Die sicherlich wichtigste Gruppe ist die der Buchstabentasten, die insgesamt 26 Mitglieder enthält.

Bemerkenswert ist, dass die Konstantenwerte in Keys mit den ASCII-Codes für Großbuchstaben identisch sind.

Für die Zahlentasten legt Keys die folgenden Werte fest. Auch hier stimmen die Konstantenwerte mit den ASCII-Codes überein.

In der Tabelle 20.4 sind die Werte der Zustandstasten enthalten. Die von uns üblicherweise als Alt bezeichnete Taste heißt hier Menu. Das stammt vermutlich daher, dass die (Alt)-Taste sehr häufig zur Menüauswahl eingesetzt wird. Es ließen sich sogar noch zwei ähnlich lautende Tabellen mit Konstanten für die Zustandstasten angeben, die dazu dienen, zwischen der linken bzw. rechten Anordnung zu unterscheiden. Allerdings dürfte das in der Praxis nur wenig Bedeutung haben.

Sehr häufig anzutreffen sind die hinter den Funktionstasten befindlichen anwendungsspezifischen Funktionalitäten. Vielleicht wundern Sie sich, dass Konstanten für insgesamt 24 Funktionstasten definiert sind. Tatsächlich gibt es aber auch solche Tastaturen, obwohl zwölf Funktionstasten derzeit der De-facto-Standard sind.

Bei diesen Tabellen wollen wir es belassen. Wenn Sie über die anderen Tasten die Konstantenbezeichner erfahren wollen, sollten Sie in der Dokumentation der Keys-Enumeration nachlesen.

Wie man mit den Keys-Konstanten arbeitet, zeigt das folgende Beispiel eines Fensters, das eine Textbox (Name = txtWindowState) enthält. Die Benutzereingabe wird im Ereignis KeyDown überprüft. Gibt der Anwender einen der Buchstaben M, N oder I ein, wird je nach Buchstabe die WindowState-Eigenschaft der Form auf maximiert, minimiert oder normal eingestellt.

Der Tastencode wird mit der Eigenschaft KeyCode des KeyEventArgs-Objekts abgefragt. Es spielt dabei keine Rolle, ob der Anwender die Zeichen als Groß- oder Kleinbuchstaben eingibt, denn ausschlaggebend ist einzig und allein die gedrückte Taste und nicht das Zeichen. Ist eine Unterscheidung zwischen Groß- und Kleinschreibung zwingend notwendig, gibt es zwei Alternativen: Entweder wird der Zustand der (Shift)-Taste abgefragt oder – was einfacher ist – es wird nicht das Ereignis KeyDown, sondern das Ereignis KeyPress behandelt.

Die Eigenschaft »KeyData«

Weiter oben haben Sie gesehen, dass drei Eigenschaften der KeyEventArgs-Klasse vom Typ Keys sind und unterschiedliche Tastenzustandsinformationen liefern: KeyCode, KeyData und Modifiers. Sie wissen inzwischen auch, dass jeder Tastendruck die Ereigniskette KeyDown und KeyUp zur Folge hat. Im Beispiel KeyDownDemo wurde die Eigenschaft KeyCode dazu benutzt festzustellen, welche Zeichentaste zum Ereignis KeyDown führte.

Werden mehrere Tasten gedrückt, löst jede gedrückte Taste ein KeyDown-Ereignis aus. Bei der Untersuchung einer Tastenkombination interessiert aber nicht die einzelne Taste, sondern die Gesamtheit aller gleichzeitig gedrückten. Um diese Information zu erhalten, wertet man die Bitmaske der vier Byte großen Eigenschaft KeyData aus. Die beiden untersten Bytes beschreiben, welche Tasten der Anwender gedrückt hält. Hiervon sind nur die Zustandstasten (Alt), (Strg) und (Shift) ausgenommen, deren Zustand den oberen beiden Bytes zu entnehmen ist.

Dazu ein Beispiel. Die Taste (F9) wird durch die Zahl 120 beschrieben, deren Bitmuster

ist und hexadezimal 0x0078 lautet.

Vorausgesetzt, es ist nur eine Taste gedrückt, hat KeyData denselben Inhalt wie KeyCode. Wird beispielsweise nur die (F9)-Taste gedrückt, führen die beiden folgenden Codefragmente demnach gleichermaßen zum Schließen der aktuellen Form:

oder

Wie erwähnt, repräsentiert KeyData eine vier Byte große Bitmaske, von der die beiden obersten Bytes die Zustandstasten beschreiben. In Tabelle 20.4 finden wir zwar im Zusammenhang mit den Zustandstasten drei Keys-Mitglieder (ShiftKey, ControlKey und Menu) aufgeführt, allerdings sind deren Werte in den beiden untersten Bytes angesiedelt und für die Auswertung von KeyData bedeutungslos. Deshalb enthält die Keys-Enumeration noch vier weitere Mitglieder.

Beachten Sie, dass der Wert für die (Alt)-Taste nun tatsächlich auch Alt heißt und nicht mehr Menu. Bemerkenswert ist, dass in Abhängigkeit von der gedrückten Zustandstaste immer nur ein ganz bestimmtes Bit im dritten Byte gesetzt wird:

Sind mehrere Zustandstasten gleichzeitig gedrückt, werden die zugeordneten Bits einfach bitweise ODER-verknüpft.

Sehen wir uns nun an einem Beispiel an, wie einfach eine bestimmte Tastenkombination abgefragt werden kann. Ausgangspunkt sei die Forderung, mit der Tastenkombination (Shift) + (Alt) + (F9) das aktuelle Formular zu schließen:

Es werden die Keys-Werte der gewünschten Kombination mit dem bitweisen ODER-Operator verknüpft und das Ergebnis mit dem aktuellen Inhalt von KeyData verglichen. Stimmt die gewünschte Tastenkombination mit dem vorliegenden Bitmuster überein, wird die Methode Close auf das aktuelle Form-Objekt aufgerufen.

Die Eigenschaft »Modifiers«

Mit Modifiers werden alle drei Zustandstasten zusammen beschrieben. Das entspricht dem Inhalt der oberen beiden Bytes von KeyData. Damit gilt folgerichtig auch, dass die bitweise Verknüpfung von Modifiers und KeyCode der Inhalt von KeyData ist.

Eine ergänzende Alternative zu der Eigenschaft »Modifiers«

Die Klasse Control hält für ihre abgeleiteten Klassen eine weitere Möglichkeit bereit, den Status der drei Zustandstasten festzustellen: Es ist die statische, schreibgeschützte Eigenschaft ModifierKeys.

Während die Eigenschaft Modifiers der Klasse KeyEventArgs immer an das KeyDown oder KeyUp-Ereignis einer bestimmten Komponente gebunden ist, agiert die Eigenschaft ModifierKeys vollkommen ereignisunabhängig und ist somit auch unabhängig von jeglichem Steuer-element. Sie wird auf die Klasse Control aufgerufen und liefert wie Modifiers den Zustand der Tasten (Alt), (Strg) und (Shift). Damit wird es möglich, die Zustandstasten auch im Zusammenhang mit Ereignissen auszuwerten, die darüber keine Informationen liefern.

Das folgende Codefragment ist der Ereignishandler des Click-Ereignisses einer Schaltfläche. Obwohl das Ereignis keine Tastaturinformationen bereitstellt, wird ein Meldungsfenster geöffnet, wenn entweder die (Alt)- oder die (Shift)-Taste während des Klickens gedrückt ist.

Soll eine Kombination mehrerer Zustandstasten zu einem bestimmten Anwendungsverhalten führen, müssen die entsprechenden Enumerationskonstanten mit dem bitweisen Or-Operator verknüpft werden. Im folgenden Beispiel wird das Meldungsfenster nur angezeigt, wenn (Alt)- und (Shift)-Taste gleichzeitig gedrückt sind:

Die Eigenschaft »SuppressKeyPress«

Möchten Sie verhindern, dass eine oder mehrere Tasten vom Steuerelement empfangen und verarbeitet werden, setzen Sie im Ereignishandler SuppressKeyPress=True.

Mit diesem Codefragment wird das Drücken der Taste (A) unterdrückt und nicht zur Verarbeitung an das Steuerelement weitergeleitet.

20.1.3 Das Ereignis »KeyPress« 

Die bisher besprochenen Eigenschaften KeyDown und KeyUp behandeln ganz allgemein das Drücken einer Taste auf der Tastatur. Viele Tasten erzeugen aber Zeichencodes, die für das Ausgabeziel bestimmt sind. Bei diesen Tasten wird zwischen KeyDown und KeyUp ein weiterer Event ausgelöst: KeyPress.

Der Ereignishandler von KeyPress empfängt ein Argument vom Typ KeyPressEventArgs mit Daten zu dem Ereignis, die nur durch zwei Eigenschaften beschrieben werden: KeyChar und Handled.

Die Eigenschaft »KeyChar«

Die Eigenschaft KeyChar enthält das ASCII-Zeichen der gedrückten Taste.

Um den Unterschied zwischen den Ereignissen KeyDown und KeyUp und KeyPress zu verdeutlichen, ist das Beispiel KeyDownDemo nun so umgeschrieben, dass die Benutzereingabe nicht mehr von KeyDown, sondern von KeyPress ausgewertet wird.

Rufen wir uns noch einmal in Erinnerung: Im Beispiel KeyDownDemo wurde nur die gedrückte Taste ausgewertet. Der Zustand der Taste (Shift) spielte dabei keine Rolle. Deshalb wurde auch nicht zwischen der Groß- und Kleinschreibung unterschieden, und das Programm reagierte in beiden Fällen gleich. KeyPress wertet jedoch den ASCII-Code aus, der bekanntlich bei den Klein- und Großbuchstaben anders ist. Der Anwender wird also gezwungen, »M« und nicht »m« einzugeben, um das Fenster zu maximieren.

Die Eigenschaft »Handled«

Normalerweise werden Tastatureingaben automatisch verarbeitet. Gibt der Anwender in einer Textbox den Buchstaben »A« ein, wird dieser sofort im Steuerelement ausgegeben. Die Tastaturereignisse sind meist dann von Interesse, wenn die Benutzereingabe ausgewertet werden muss. Das wäre zum Beispiel der Fall, wenn eine bestimmte Eingabe unterdrückt und durch eine andere ersetzt werden soll.

Nehmen wir an, dass die Eingabe eines Umlauts automatisch durch »ae«, »oe« bzw. »ue« ersetzt werden soll. Am einfachsten ist es, den Inhalt der Textbox mit der Eigenschaft SelectedText zu manipulieren, um eine Zeichenfolge direkt in die Anzeige der Textbox zu schreiben. Ist ein Teil der Zeichenfolge markiert, werden die markierten Zeichen durch die neue Zeichenfolge ersetzt, ist kein Text markiert, wird die Zeichenfolge an der aktuellen Cursorposition eingesetzt.

Geben wir in das mit textBox1 bezeichnete TextBox-Objekt »Händler« an der Tastatur ein, wird die Ausgabe jedoch Haeändler lauten. Das Programm hat zwar die Eingabe des Umlauts richtig erkannt und »ae« in die Textbox geschrieben, allerdings sorgt die automatische Eingabeverarbeitung auch dafür, dass der unerwünschte Umlaut weiterhin ausgegeben wird. Aber das war es doch nicht, was wir wirklich wollten.

Jetzt kommt die Eigenschaft Handled ins Spiel. Handled ist vom Typ Boolean und steht per Default auf False. Dahinter steckt die Aussage, dass die Komponente die Eingabeverarbeitung vornimmt. Wird Handled=True gesetzt, schalten wir die automatische Eingabeverarbeitung aus und nehmen die Ereignisbehandlung selbst in die Hand.

Damit unser Beispiel wie gewünscht arbeitet, müssen wir den Code folgendermaßen ergänzen:

Die Anweisung e.Handled=True darf übrigens nicht nach der letzten if-Anweisung stehen. Wenn Sie das machen, schalten Sie – bis auf die Umlaute – die Behandlung aller anderen Zeichen ab.

Abschalten einer bestimmten Taste

Manchmal kommt es vor, dass man die Funktionalität einer bestimmten Taste nicht zulassen kann und diese deaktivieren muss. Auch hierzu bietet sich Handled an.

Im folgenden Codefragment wird die (Home)-Taste (= (Pos1)) abgeschaltet. Damit wird es dem Anwender unmöglich gemacht, den Eingabecursor an die erste Position zu setzen. Dass das mit den Steuerungstasten immer noch möglich ist, übersehen wir hierbei großzügig.

Mit der Taste »Return« zur nächsten Textbox navigieren

Normalerweise wird mit der Tabulatortaste von einer Textbox in die nächste gesprungen. Manche Anwender verwenden aber stattdessen die (Return)-Taste. Das folgende Beispiel soll zeigen, wie das Drücken von (Return) abgefangen und das nächste Steuerelement fokussiert wird. Dabei hilft uns die Methode ProcessTabKey der Form weiter. Dieser übergeben wir Tue, um das nächste in der Fokussierreihenfolge stehende Steuerelement zu erreichen.

20.1.4 Die Tastaturereignisse der Form 

Als abgeleitete Klasse von Control erbt auch die Klasse Form die Tastaturereignisse. Diese werden jedoch unterdrückt, sobald die Form ein Steuerelement enthält, das selbst in der Lage ist, Tastaturereignisse zu verarbeiten. Manchmal möchte man aber bestimmte Tasten nur von der Form – in seltenen Fällen sowohl von der Form als auch von einem Steuerelement – verarbeiten lassen.

Damit das Fenster dennoch in die Lage versetzt wird, Tastaturereignisse zu empfangen, muss die Eigenschaft KeyPreview des Form-Objekts auf True gesetzt werden. Jedes Tastaturereignis wird dann zuerst von der Form entgegengenommen und erst danach vom aktiven Steuerelement. Die Ereignisfolge ist wie folgt:

Soll mit der Einstellung KeyPreview=True ausschließlich die Form für die Verarbeitung eines der drei Tastaturereignisses verantwortlich sein, muss im entsprechenden Ereignishandler der Form Handled=True gesetzt werden. Die Auslösung des entsprechenden Ereignisses des Steuerelements wird damit verhindert.

20.1.5 Senden von Tastatureingaben 

Mit der statischen Methode Send der Klasse SendKeys aus dem Namespace System.Windows.Forms können Sie eine Tastatureingabe auch mittels Programmcode simulieren, z.  B.:

Empfänger der Zeichenfolge ist dann das Steuerelement, das über den Eingabefokus verfügt. Damit ließe sich auch das Beispiel HandledDemo wie folgt codieren:

Die Send-Methode nimmt eine Zeichenfolge entgegen, die in der einfachsten Form nur in Anführungsstrichen übergeben wird. Wie wir aber wissen, kann eine Tastatureingabe auch mit einer Taste erfolgen, die kein Zeichen ausgibt. Für diese Tasten gilt eine besondere Festlegung: Sie werden durch einen festgelegten Zeichencode beschrieben, der in geschweifte Klammern eingeschlossen wird. Die folgende Anweisung simuliert beispielsweise das Drücken der (F4)-Taste:

Die Zeichencodes, die den einzelnen Tasten zugeordnet sind, können Sie der Dokumentation der Klasse SendKeys entnehmen.

Wollen Sie eine Tastenkombination mit den Zustandstasten (Shift), (Strg) und (Alt) simulieren, wird der jeweilige Buchstabe in runden Klammern angegeben und davor ein Codezeichen gesetzt. Die drei Codezeichen können Sie der Tabelle 20.8 entnehmen.

Die Anweisung für die Tastenkombination (Shift) und (A) lautet dann:

Neben der Methode Send enthält die Klasse SendKeys noch die Methode SendWait, die zuerst auf die vollständige Verarbeitung der Tastatureingabe wartet.